Service creation in an intelligent network

ABSTRACT

An alternative method to the existing manual service creation exploits the properties of genetic programming (GP) to produce service logic programs for an intelligent network. For GP to be of benefit to an intelligent network, it must be able to reduce the time to create a service and reduce the number of implementation errors in the resultant program.

As telecommunication systems become more complex and the effort neededto create services in a timely manner becomes greater, so the need foralternative means of realising systems becomes more urgent.

It has been considered how a method from the field of evolutionarycomputing can be of assistance in the field of Intelligent Networks (IN)in helping to create new telecommunications services.

The premise used is that in a branch of evolutionary computing, a systemcan translate a specification into an implementation without the directassistance of a human programmer. The benefits to be gained are fastersystem realisation and a more reliable implementation by focusing theeffort on the requirements of a system rather than it's implementation.

Starting from the idea that some form of automatic programming was afeasible method to use, a detailed analysis of one method—GeneticProgramming (GP)—was made. From this analysis a number of questions wereraised concerning the basic feasibility, performance and scalability.

Traditional telephony in the past 20 years has concentrated on deliverytelephony services to customers by means of stored program switches.Customers have, until recently, been restricted to relatively crudeterminal equipment that supports voice and Dual Tone Multi Frequency(DTMF) user controls.

As the number of services offered has grown and the sophistication oftelephone equipment has risen, it has become clear that offeringservices via the traditional embedded switch technology does not scalewell, and that other platforms for providing the services are required.

One approach used is Intelligent Networks (IN), the primary objective ofIntelligent Networks being to move the service computation to readilyavailable computers. A basic Intelligent Network is shown in FIG. 1.

The functions carried out by the various components of the IntelligentNetwork are:

Key Name Function BCSM Basic Call State Machine The description of theinternal operation of the IN portion on an SSP SCP Service Control PointThe computing platform that executes the service logic SCEP ServiceCreation Environment Used to create the services that Point execute onthe SCP SDP Service Data Point Supplies database functionality SMPService Management Point Used to manage the network and subscriber dataSSP Service Switching Point Performs normal telephony and associatedservice triggering

A secondary aim of introducing IN was to reduce the time required todevelop and deploy new services. Traditional switch based solutionstypically require 2 years from the initial requirements being specifieduntil the service is in operation. In a highly competitive environmentthis is too long, and the market window will have disappeared by thetime the services come into operation. IN aims to reduce this byexploiting mainstream IT techniques.

In the following references to the bibliography will be indicated by[XXXNN] and details of the references are placed at the end of thedescription.

One such system has been developed by the former GPT Limited, nowMarconi Communications Limited and is marketed as GAIN Inventor(™). Thisemploys a service creation life-cycle shown in FIG. 2. This shows asimplified waterfall model where the stages 1-4 as a whole map tosub-goals 2 to 7 described by Boehm [Boe81] Chap. 4. Page 37. Animplicit assumption is that the feasibility of a service has alreadybeen established. Maintenance and phase out are part of the servicecreation process but are not considered for development purposes.

The first two phases occur when either a customer specifies theirservice requirements directly to the provider of the network, or as aresult of collaboration between user and provider. They are carried outusing the tools and techniques provided by the IN equipment vendor.During the requirements capture phase, it is quite likely that the sametools will be used in order to produce rapid prototypes to that thecustomer can verify the essential requirements early on in thedevelopment of the service.

In the GAIN Inventor(™)system the user selects sets of iconic imagesfrom a palette and joins them together to create a directed graph. Eachnode (icon) in the graph has a set of attributes that the servicecreator can change to determine the eventual behaviour of the servicebeing constructed.

A compiler is used to translate the abstract service representation to Ccode that conforms to the requirements of the run-time environment.

Experience has shown that the time required to complete the first phaseis relatively short, but the time required to implement complex servicesin phases 2 and 3 can be several months. A typical non-trivial servicecan require several thousand icons, and results in dozens of validtraversals of the graph. A means of reducing the duration of thesephases is therefore of benefit to the network and service operators.

The major problems encountered in the existing system are associatedwith software engineering management issues namely, productivity andquality control. Despite the promises of the early IN systems and theadvanced tools available, complex services still take a considerableamount of time to develop using traditional software engineeringtechniques and there is still a level of defects found in the servicethemselves.

The present invention addresses the difficulties with the first twophases by automatically deriving an implementation from therequirements, or as Teller (TA97], Langdon [Lan98] and others put it, byusing Automatic Programming. This approach was hinted at by Boehm[Boe81] Chap. 33 where a mention is made of automatic programming. In1981 the idea was considered interesting but ‘somewhat beyond thecurrent frontier of the state of the art’. It is demonstrated thatautomatic programming such as by using Genetic Programming (GP) forexample is now a viable alternative in the domain of IN.

GP has demonstrated that it can produce results that are at least asgood as a human programmer and in some cases provide solutions toproblems that a human has not been able to achieve as in the case ofdiscovering an electronic circuit to yield a cube root function [KBF96],and to create a rule for cellular automata that has also shown thatprograms for Digital Signal Processors (DSPs) evolved using GP canoutperform existing programs.

An existing service creation case study can be considered. This studyshowed that for t a complex service a human required 4.5 man years ofeffort to analyse, design, code and test the service. The principalmeasurable attribute is therefore the elapsed time required to implementthe service and this attribute will be quantified for GP by experimentaldata presented later. Other attributes are cost of equipment and thedegree of human intervention required but are not considered further inthis work.

A key measurable attribute of the program is the level of defects.Broadly defects fall into one of two categories [Som96]; errors due toincorrect requirements analysis and errors due to implementationdeficiencies either by errors in programming or design. The first typeis common to whatever method of programming is adopted. As summarised byDavis [Dav93] the earlier requirement related errors are found, thelower the cost to remedy the error. As will be seen later using GPforces the designer to consider requirements in more detail initially(for fitness evaluation) so the implication is that using GP will resultin fewer errors introduced by faults in the requirements. Even usingadvanced tools such as Inventor, in one case there were 15 failuresassociated with the service. Anecdotal evidence suggests that these wereall implementation errors.

There is no existing information on using GP for IN services creation.

The question of whether GP can scale can only be answered in full byanalysing experimental data, but initial indications show that GP cancreate programs to solve complex problems in other domains.

It is worth noting that other alternatives such as artificial neuralnetworks, hill climbing, decision trees, reinforcement learning,combinatorial search or knowledge based systems have not been exploredin the context of this problem, but Koza [Koz96] makes a powerfulargument why such a comparison would not be beneficial anyway. The mainpoint of his argument is that most machine leaning paradigms are highlyspecialised and any attempt to do a cross paradigm comparison will‘gravitate to utterly trivial problems’.

Notwithstanding the above, one area that promises to offer a viablealternative to GP is Inductive Logic Programming [BG95], and a usefulcomparison has been made between Inductive Logic Programming and GP byTang [TCM98] albeit for a fairly simple problem. Furthermore somelimited experimental results have been presented between traditionalGenetic Algorithms (GA) and GP in the domain of telecommunicationsapplications by Sinclair [SS97 and Aiyarak [ASS97]. None of thesecomparisons offers any convincing arguments in favour of any particularmethod, indeed, the comparisons between GA and GP give contradictoryresults and appear to be heavily influenced by the type of problem beingsolved.

According to the present invention there is provided a method ofcreating a service for an Intelligent Network (IN) system, the servicehaving a series of service requirements, the method comprising the stepsof:

(a) Using Evolutionary Programming to derive programs to operate a BasicCall State Machine of the IN to provide the service from the servicerequirements;

(b) Evaluating a fitness function for programs.

(c) Selecting a program from those derived.

There is further provided a service creation means as claimed in anyoneof claims 8 to 10, wherein the fitness evaluating means provides theweighted sum of the number of correctly sequenced messages that aService Switching Point (SSP) in an IN would receive and the weightedsum of the number of correct message parameters that the SSP wouldreceive.

In both cases a preferred form of Evolutionary Programmning is GeneticProgramming.

The present invention will now be described by way of example, withreference to the accompanying drawings, in which:

FIG. 1 shows the basic elements of an intelligent network;

FIG. 2 illustrates a service creation life-cycle;

FIG. 3 shows a flowchart of genetic programming;

FIG. 4 illustrates the operation of crossover in genetic programming;

FIG. 5 shows a layout of autonomous polymorphic addressable memory;

FIG. 6 shows a message sequence chart for a simple number translationservice;

FIG. 7 shows a state diagram for a simple number translation service;

FIG. 8 shows the performance of a simple number translation for m=500;

FIG. 9 illustrates a message sequence chart for an extended numbertranslation service;

FIG. 10 shows a state diagram for extended number translation;

FIG. 11 shows the performance of complex number translation for m=500;

FIG. 12 shows an example of a program tree for complex numbertranslation −1;

FIG. 13 shows an example of a program tree for complex numbertranslation −2;

FIG. 14 shows an example of a program tree for complex numbertranslation −3;

FIG. 15 illustrates the size of fittest individual with generation;

FIG. 16 shows the progression of state fitness evolution;

FIG. 17 shows the progression of message fitness evolution;

FIG. 18 shows the message sequence;

FIG. 19 shows the state diagram;

FIG. 20 shows the performance of early decision making for m=500;

FIG. 21 shows a message sequence chart for late decision experiments;

FIG. 22 shows a state diagram for late decision experiment;

FIG. 23 shows the performance of late decision making for m=500;

FIG. 24 shows the performance using reduced complexity functions form=500;

FIG. 25 shows an example program tree using reduced complexityfunctions; and

FIG. 26 shows a simple ‘C’ program.

Genetic Programming (GP) is an extension of Genetic Algorithms (GA)first proposed by Holland [Hol92] where the individuals that make up apopulation are not fixed length, limited alphabet strings, but ratherstructures that represent programs. The structures are typically treesthat describe the program [Koz92], but may take on other forms such asbinary string [Ban93]. The purpose therefore is to evolve programs thatcan solve the problem presented to the system.

GP uses four steps to solve a problem:

1. A set of individuals (programs) is randomly created. This is theinitial population.

2. These are then evaluated (executed or interpreted) for fitness, and afitness value is assigned to each individual.

3. These individuals are then used to form the next population by meansof probabilistically selecting one of:

asexual reproduction

sexual reproduction or crossover

mutation

4. This cycle is repeated until either a pre-determined number ofgenerations have been processed or an individual meets a predeterminedlevel of fitness.

This is illustrated as a flow chart in FIG. 3.

In class tree based GP each genetic program consists of one or morenodes, chosen from one of two sets. The non-leaf nodes are known as thefunction set F={ƒ₁ . . . ,ƒ_(n)}.

All nodes in F have arity (that is can take a number of arguments) oneor greater. The leaf nodes are the terminal set T={t_(1 . . .) t_(n)}.Nodes in T have arity of zero.

If the members of T are considered as functions with arity zero, thenthe total set of nodes is:

C=F∪T

The search space is the set of all possible compositions of the membersC. This set must exhibit two properties [Koz92]: closure andsufficiency.

Closure requires each member of C to accept as its arguments any othermember in C. This property is required in order to guarantee thatprograms can operate without run-time errors being generated. The commonexample cited is that of protecting the division operator to preventdivision by zero errors, but also extends to data types used whencalling functions and accessing terminal types.

This may be achieved in a number of ways. Firstly Koza [Koz92] restrictsthe types of arguments and function return types to compatible. Forinstance, all floating point types as in the symbolic regressionexamples or logical in the Boolean examples. For simple problems withsingle data types this is sufficient.

Secondly, in strongly typed approaches such as those described byMontana [Mon95] and Haynes et al [HWSS95] constraints are placed on thecreation of individuals to satisfy the type rules. The advantage here isreducing the size of the search space by eliminating individuals thatwould fail due to syntax errors. Clack [CY97] extended this work to showthat expression based parse trees can yield more correct programs, andintroduced the idea of polymorphism into the data types. Later analternative is presented to strongly type approaches that removes someof the deficiencies.

The sufficiency property requires that the set of functions in C issufficient to express a program capable of solving the problem underconsideration [Koz92]. This is a problem specific property and must bedetermined before any GP can be evolved. This together with determininga suitable fitness test requires the most effort by a user of GP.

To create the initial population a number of randomly selecting nodesfrom the function set F is used to build trees according to the arity ofthe function. Leaf nodes from T are inserted according to certaincriteria. Two main methods are described by Koza [Koza92]; the full, andthe grow methods.

In the full method, members of F are selected until the tree reaches apre-determined depth, then from T. This results in trees with uniformdepth.

The grow method differs in that a node is selected from C if the depthis less than a pre-determined maximum, else it selects from T.

A third method combining the full and grow is called ‘ramped half andhalf’. Ramped half and half operates by creating an equal number oftrees with a depth between 2 and a pre-determined maximum. That is ifthe maximum depth is 10, then {fraction (1/9)} will have depth 2,{fraction (1/9)} depth 3 and so on up to a depth 10. Then for eachdepth, 50% of the trees are created using the full method and 50% usingthe grow method. This is claimed by Koza [Koz92] to offer a widervariety of shapes and size in the initial population. The difference inperformance between the three methods is documented in [Koz92] and[Ban93], with ramped half-and-half clearly yielding higher probabilitiesof success on a number of problems. Therefore this is the method used inall cases in the work described herein.

During the operation of GP, one of three methods of producing the nextgeneration are used, reproduction, crossover and mutation.

Reproduction is the straightforward copying of an individual to the nextgeneration, otherwise known as Darwinian or asexual reproduction.

Crossover, or sexual recombination, consists of taking two individuals Aand B , and randomly selecting a crossover point in each. The twoindividuals are then split at these points creating four sub-trees A₁ A₂B₁ B₂, and two new individuals created C and D by combining A₁ B₂ and B₁A₂. This is shown in FIG. 4.

Mutation consists of randomly selecting a mutation point in a parse treeand substituting a new randomly generated sub-tree at that point.

There is still much debate over whether crossover and mutation areuseful operators [GPMAIL]. Koza [Koza92] claims that mutation does notplay a large part in finding fit individuals and consequently does notuse it in most of his experiments. In contrast studies by Banzhaf et al[BFN99] and Luke and Spector [LS97] show that mutation can be useful insome cases, however they have not discovered any robust heuristics thatallow the section of optical settings. Finally, Angeline [Ang97a] putsforward some evidence that crossover may be a form of macro mutation andnot play any real role in propagating so called building blocks.

The two main methods of selecting individuals from a generation arefitness proportionate and tournament. When using fitness proportionate,all individuals are ranked according to their absolute fitness valuesand the best selected. A refinement on this is rank selection [GD01]which reduces the influence of single highly fit individuals.

In tournament selection, n individuals are selected and the best one inthe selection is propagated to the next generation. The value of n canbe any number greater than one. The winning individual can be left inthe donor population, resulting in so called over selection, where itstands a chance of being reselected as a result of further tournaments.

The choice of selection method was based on the work by Banzhaf [Ban93]where tournament selection with over selection performed better in mostcases, therefore tournament selection with over selection was used inthe work described later.

In order to identify good individuals, a fitness function is requiredthat can provide a measure of how good (or bad) an individual is. Someproblems use the result of the program directly as the fitness measure,for example symbolic regression. Other problems use side effects, suchas the Ant problem [JCC92] that is commonly used as a benchmark of GPsystems. The Ant problem uses a two dimensional toroidal grid containinga trail of food. A simulated ant is placed in this grid. The objectiveis to discover a controlling program that allows the ant to collect themaximum amount of food in a given time. The ant is able to more forward,turn left or right and sense food in the cell adjacent to the directionit is facing.

It was explained above that the set of functions must satisfy thesufficiency property. That is they must be rich enough to allow anevolving program to be able to satisfy the functional requirements. Forinstance, a requirement for a program to generate messages would requireone or more functions to support this. The functions selected howeveralso depend on the level of abstraction and are dealt with below.

Terminals may be side affecting or yield data. In this case, thefunctions were chosen to perform all external operations, while theterminals were chosen to yield data. In order to arrive at a sufficientset of data types, it is useful to consider what types of data arecommonly encountered in telephony services and these are summarisedbelow.

Data Type Comments telephone numbers Strings of digits [0-9#*] that canbe dissected and concatenated. The string length may be up to 24.constant integral Used for counters and message parameter values valuesboolean values Flags and status values message types An enumerated setused to distinguish messages

From this it is clear that restricting functions and terminals to use asingle data type in order to satisfy the closure property is notfeasible.

In addition, since most IN services require some state information to bestored between message transfer points, a mechanism for saving stateinformation was required. A first approach to this requirement, IndexedMemory, was suggested by Teller [Tel94] where he argues that in orderfor GP to be able to evolve any conceivable algorithm, GP needs to beTuring Complete and that addressable memory enables this. A useful sideeffect of this is that memory also allows state information to beexplicitly saved and retrieved.

Of course other approaches to saving state information are possible asfor example in the work by Angeline [Ang97b] that uses MultipleInteracting Programs (MIPS). However for the present purposes. IndexedMemory was chosen since it was thought that it would be easier toanalyse the operation of the evolving programs.

As already noted above several methods have been proposed to ensure thatthe closure property is maintained during initial creation andsubsequent reproduction. An alternative is proposed in this work, basedon polymorphic data types with independent values for each typesupported.

This approach was devised as an alternative to the strongly typedmethods by making the observation that it is possible that the criteriaused to decide what is a correct program has more to do with correctnessas seen by a human programmer rather than any inherent property of GP.In other words, strong typing is a necessary artefact of languages usedby humans to help ease the burden on the programmer, by means ofassisting machine interpretation. Perkis [Per94] has shown that anapparently haphazard mechanism in the form of a stack can yield usefulresults. Another objection to using a strongly based type system wasthat the potential number of solutions could be greatly diminished.

A data type termed Autonomous Polymorphic Addressable memory (APAM) wasused here and as shown in FIG. 5. This consists of a set of memorylocations M={L₁, . . . L_(n)} which can be addressed randomly or byname. Each location is a set of data items L={d1, . . . d_(n)}. Thevalues of L_(n).d₁, L_(n).d₂ are independent of each other. Selection ofthe correct type and therefore value is performed by any function thatis passed a memory reference as an argument.

To support this memory architecture, the terminal set T consists ofmemory nodes T={TVAR1 . . . TVARn}. Each node returns a reference tomemory address Ln. and can be passed as arguments to any function.

It should be noted that this is not the same as using a generic datatype where a data item is coerced into the correct type at run time. Adifficult with coercion is that many automatic conversions aremeaningless. For example, in the context of telephony it would be hardto imagine what the coercion of a Boolean value into a telephone numberwould mean.

The number of functions in C and their arity can be used to estimate thesize of the search space as described by [Iba96] and Langdon [Lan97. Itis clear that a large function set would result in a large search space,and therefore reduce the probability of achieving good performance.Therefore, a level of abstraction that uses smaller number of functionsis desirable.

As an example, consider several sizes for F, assuming each member of Fhas arity of two, and that there are ten members of T. The populationsize is calculated using Langdon's method [Lan97] and the resultssummarised below.

For these experiments, the level was initially pitched at the ICON levelsince this level allows humans to create production quality services,giving a potential size of F of around twenty. In this work only a smallsubset of this potential set was chosen. An attempt was made to see ifthis level of abstraction was optimal by carrying out additionalexperiments using a level closer to the API. Initial results indicatethat using the ICON level may not be the most effective.

The decision was made to measure the fitness of the GP at Interface B(FIG. 1) since this is a standardised external interface [Itu94a] andwould allow the specification of services to be performed at the networklevel.

The Basic Call State Machine (BCSM) of the standards [Itu94a] wassimplified, and i.e. called a Simple Call State Model (SCSM) in order tofocus on the GP methodology in this description rather than beingdistracted by the complexities of the BCSM.

By treating the GP as a black box it should be possible to have a highdegree of confidence that individuals operate as expected. This wouldoperate by means of sending messages to each individual and waiting foran appropriate response. At the conceptual level this is exactly what isdone, but at the practical level things are not so simple.

The initial attempt used this approach, setting a time-out against eachresponse expected, but this resulted in excessive time required to testpoor individuals since many time-outs were encountered for highly unfitindividuals. It was also very hard to debug such a system.

In order to simplify the system, the execution of the system was drivenby the service logic so that when evaluating fitness, the service logicis executed directly. It then makes requests to the SCSM as required.This inversion of roles removes the problems of detecting non-responsiveservice logic programs, and simplifies the initial debugging andverification.

When running a fitness test, there are two problem specific relatedmeasures used to determine how fit an individual is, as well asnon-problem specific measures such as parsimony:

The number of correct state transitions made. Each correct transition isrewarded with a value of 100. Each incorrect transition is penalisedwith a value of −20. The reward and penalty values are summed. Call thisvalue s.

The number of correct parameter values passed back to the SCSM. Acorrect parameter value is rewarded with a value of 100, and eachincorrect value is penalised with a value of −20. The reward and penaltyvalues are summed. Call this value p.

Raw fitness r is given r=s+p.

Normalised fitness n is given by n=k−r where k is a constant that isdependent on the number of state transitions and message parameters inthe problem being considered, such that for a 100% fit individual n=0.

A count is maintained of the number of correct and incorrect statetransitions and correct and incorrect message parameter values.

Koza [Koza92] p.191 describes a method of measuring the performance of aGP system that consists of running a large number of trials noting foreach run, whether the run yielded a correct individual, and thegeneration number that the run produced such an individual.

For a population size M, the cumulative probability of success P (M, i)for any generation i is calculated. This is a measure of the success ofthe particular set of configuration settings. From this it is possibleto estimate the effort required to find a satisfactory outcome. Thecumulative probability P (M, i), is the total number of runs thatproduced a successful outcome up to and including generation i, dividedby the number of runs conducted.

From this, an estimate can be made of the number of independent runsrequired to reach a satisfactory result with probability z forgeneration i, using equation 1 ([koz92] p.194): $\begin{matrix}{{R(z)} = \left\lbrack \frac{\log \left( {1 - z} \right)}{\log \left( {1 - {P\left( {M,i} \right)}} \right)} \right\rbrack} & (1)\end{matrix}$

In all cases described z=99%.

The quantities P (M, i) and R (z) are plotted on a graph.

The effort ε required to find a solution by generation i is given forequation 2:

ε=M.R(x)  (2)

Additional information collected includes the total time taken for eachrun (τ), the number of individuals processed, the number of uniqueindividuals that were 100% fit (Ψ), the number of 100% individuals atthe final generation (υ) and details of the best individual of each run.

A summary of the implementation would be as follows:

(a) The set of functional components and data storage components must beconstructed to meet two theoretical constraints; they must be sufficientto be able to construct a program that meets the requirements, and theymust satisfy the closure property so that they may be combined in anyarbitrary order and still form a program that can be executed. Asuitable set of functional components for a number translation serviceis:

FSTART. Accepts an InitialDP message from the network and decodes themessage parameters, placing them in data storage locations.

FDBREAD. Makes a database request using a data storage location for thekey, and placing the result of the request in a data location.

FROUTE. Issues a Connect message to the network, using a data locationto furnish the destination route address.

STRSUB. Applies a string truncation operation to the contents of a datalocation.

The data storage components consist of a set of memory cells that cancontain one or more data types at the same time.

Both the functional components and data storage components are thenencoded as software modules ready for incorporation into the GeneticProgramming system.

(b) An initial representation of the specification of a service is amessage sequence chart of which an example is shown in FIG. 1.

This is then translated into a state diagram such as is shown in FIG. 2.This specification can then be transformed into a data structuresuitable for processing by the Genetic Programming system.

(c) The Genetic Programming system requires a fitness function thatevaluates the fitness of individual programs. For service creation, thefitness is the weighted sum of the number of correctly sequencedmessages that the SSP sees and the weighted sum of the number of correctmessage parameters that the SSP sees. Additional evolutionary pressureis imposed to evolve a parsimonious solution.

The fitness function is therefore a simulation of the SSP interface thatcan send a message to an individual program with data parametersaccording to the state diagram derived for FIG. 2 and accept messagesand inspect message parameters again according to the state diagram. Theresult of the fitness function is an integral value with smaller numbersrepresenting better fitness.

(d) Given the data structure or structures describing the requiredservice specification, the software modules that encode the functionalcomponents and data storage components, and an implementation in theappropriate programming language of the fitness function the GeneticProgramming system is then built using new or existing softwarecomponents.

The system is then run for a pre-determined number of times, usingpre-determined generation numbers and population sizes. The systemnotifies the user of the number of 100% correct individual programs thatwere generated during the run. The most suitable individual program isthen selected for translation into a form suitable for execution on thechosen Intelligent Network platform.

A series of experiments were conducted using a set of increasinglycomplex service scenarios based on a simple but complete numbertranslation service. Number translation, also popularly known as‘freephone’ or ‘premium rate’ is the most common service offered by INplatforms [Ebe98. Further scenarios look at how error conditions anddecisions can be handled within the evolving service.

This shows how the present invention may be implemented.

A number of simplifying assumptions were made at the start:

the number of functions present in the function set was limited in orderto concentrate on the essential requirements of services.

the external world is implemented such that the SDP is integrated withthe SCSM to ease the job of the fitness evaluation function. In the realworld the two would be separate functions.

the number of parameters passed in the messages was limited in order toease the implementation of the fitness function.

The system supports five message types analogous to the real worldIntelligent Network Application Part (INAP) and SDP operations. Theseare summarised below.

Equivalent Message INAP/SDF type message Parameters Comments IDPInitialDP CalledDN The message is and flag generated by the SSP as aresult of a trigger detection point being activated by a call. DREQDB_REQUEST Key A database request. DBRESP DB_RESPONSE Result and Theresponse from the status of database. request CONNECT Connect TranslatedAn instruction from Address the SCF to the SSP to connect party A toparty B. END Pre-arranged end None A message issued by either end of aTCAP link to terminate an active session

The function set F selected for the initial set of experiments consistsof five functions: FSTART, FROUTE, FDBREAD, FEND and STRSUB.

FSTART takes two arguments. The first argument is evaluated, and theparameter value passed in a DBREQ message sent to the SCSM. It thenaccepts a DBRESP message and the second argument is evaluated, and theparameter value from the message is stored at the location returned.Finally, the third argument is evaluated and returned. DB_REQUEST andDB_RESPONSE are proprietary messages used by GPT Limited for SCF to SDFconmmunication.

FROUTE takes two arguments. The first argument is evaluated and theparameter value used in the Connect message sent to SCSM. The secondargument is then evaluated and returned.

FEND takes one argument, which is evaluated and returned. An END messageis sent to SCSM.

STRSUB was included because real life services require digit stringmanipulations. It takes two arguments, which are both evaluated. Thestring value from the first argument is shifted left by one characterand stored at the location returned by the second argument.

The result of the second argument is returned.

A simple translation service is required to translate an incoming numberto a new number. Typically this is done by means of using the incomingnumber (CalledDN) as a key to read the new number from a database, andto issue a connection command to the SSP with the translated address(TAD). A message sequence chart for this service is shown in FIG. 6.

The external operation of this service as follows:

1. The SSP sends an initial trigger message called the Initial DetectionPoint (IDP) containing the number (CalledDN) dialled by the user (the Aparty).

2. The service logic makes a request to the SDF to get the real numberto route the call to.

3. The SDF returns the number (TAD) to the service logic.

4. The service logic sends a Connect message to the SSP, causing it toroute the caller (A party) to the correct number (B party).

5. The SCP sends an END message to the SSP indicating that the servicelogic has relinquished control of the call and is no longer concernedwith any events generated by the SSP as a result of the callprogressing.

Note: CalledDN <<1 denotes that the CalledDN string is shifted left byone character, discarding the 1^(st) character. This is used to simulatethe real world operational requirement to modify the digit string insome way, for instance to strip any leading zeros from a nationalnumber.

From the message sequence chart an external state model can be derivedas shown in FIG. 7.

This experiment was evaluated using a range of populations between fiftyand five hundred to determine the behaviour for different populationsizes. Fifty independent runs were made for each population, and thetotal number of successful outcomes for each generation was recorded.

Each run was allowed to complete to generation 200, irrespective ofwhether it had found a 100% fit individual.

The results are shown below. A good run is where a 100% fit individualwas produced or formally where P(M,200)>0.

Population M Number of good runs Time τ (secs) 50 12 105 100 22 326 15035 476 200 42 783 250 42 971 300 49 1159 350 48 1382 400 50 1749 450 481937 500 50 2140

Two points can be deduced from these results. Firstly, even for smallpopulation sizes, a significant number of successful and thereforeuseful programs were generated. Secondly, the running time is roughlyproportional to the population size.

The raw data was then processed to show the probabilities of success andthe number of independent runs required. This is shown graphically inFIG. 8 for a population size M of 500. Note that R(z) is proportional tothe effort required from equation (2).

Since for a population of 500, there was an 80% probability of success,this population size was used subsequently.

Number successful at Number of different Effort ε generation 200   100 %fit programs 1,500 50 50

Complex number translation was now considered where there is anadditional database request, and additional variable manipulationrequirements. This scenario occurs in the real world where a servicerequires two items of data in order to route a call. For example, aservice may need to route to one number during working hours and anothernumber during out of work hours. The first database request in thisexample represents the query that determines a time based key for thesubsequent request. Again a message sequence chart and state diagram areshown in FIG. 9 and FIG. 10.

The performance of this experiment is shown graphically in FIG. 11 and asummary of the performance is shown below.

Number successful at Number of different Effort ε generation 200   100%fit programs   2,000 49 49

The main conclusion that can be drawn from the above is that incomparison with the simple case, more processing effort was required.

Some sample 100% correct programs from this experiment are shown inFIGS. 12, 13 and 14, taken from the run when M=500, from runs 1, 9 and13.

From these three examples, the potential variety of solutions thatappear can be seen. It is possible that a human programmer would havecome up with that shown in FIG. 13, since this begins with the FSTARToperation, followed in sequence by the other operations, although usingthe side effect of node 5 is not intuitive. It is unlikely that a humanwould have started with the FROUTE operation. The variety can also beseen from the fact that the 49 successful runs produced 49 differentsolutions.

It is also interesting to note the presence of unproductive nodes. Forinstance, in FIG. 14, node <10> performs an STRSUB between TVAR5 andTVAR6. TVAR5 is not used again, until it is overwritten with the resultof a shift at node 14, therefore node <10> is a redundant non resultaffecting node.

The presence of these unproductive nodes—called introns—is part of theevolutionary process. It has been argued by Nordin [NFB96] that thepresence of introns can help the evolutionary process by isolatingproductive sequences from other sequences, and thus preserving them forfuture generations. The presence of these introns can be seen byobserving the change in population size of totally fit individual whilerunning the GP system.

The presence of introns during evolution is shown in FIG. 15 for M=500,run number 24. The plot shows the normalised fitness and tree size ofthe fittest individual for each generation. It is important to note thatthis does not shown any one particular individual throughout the run.

As the fitness improved, the size of the fittest individual tended toincrease initially presumably due to the effects of crossoverintroducing new material to the fittest individual, or due to otherfitter individuals being produced. It can also been seen that the sizeincreased at the same point that an improvement was made to the fittestindividual. However additional pressure to evolve parsimoniousindividuals resulted in each stable case decreasing in size. This istrue even for the 100% fit individual the appeared at generation 53.

The problem presented here has two distinct measures for fitness:

1. Whether states are handled correctly.

2. Whether the message values returned from the program are correct.

It is interesting to observe the rates at which the system can findtotally fit solutions. To do this, the number of successful andunsuccessful state transitions and messages was recorded by the SCSM foreach generation.

FIG. 16 shows the progression of the states for M=500, run number 19,and FIG. 17 shows the message fitness progression.

This shows that the state handling is quickly evolved, with 100% of thestates correctly handled by the fist generation. However, there arestill a number of extra incorrect states present until generation 25.This can be attributed to the fact that bad states incur a penalty of20, while good states are rewarded with a value of 100.

By comparing FIG. 16 and FIG. 17 it can be seen that message fitnesslags behind the state fitness. This is because a correct message cannotbe delivered until the correct state handler is in place.

The implication of this behaviour is that if there are fitness measures(as in message parameter values) that are completely dependent on otherfitness measures (such as the message ordering), the effort required toevolve solutions increases. There is therefore effectively a hierarchyof fitness and there is expected to be a practical limit to the depth ofsuch a hierarchy.

Experiment 3. Run-time Decision Making—Simple Case

The cases studied so far require a linear sequence of message exchangesand the correct data passed with those messages, but in real lifesystems exceptions occur which must be handled. Additionally, servicesoften make decisions based on the current state, user inputs, databasevalues or environmental factors such as the time or date.

This experiment was designed to discover if logic could evolve to handlethese cases.

The simple case requires the service logic to return one of two numbersdepending on the value of a flag that is passed into the service fromthe SSP. Such a flag may indicate that a particular caller is deniedaccess to parts of a service.

The message sequence is shown in FIG. 18 and the state diagram in FIG.19.

To handle run-time decisions, two changes are required to the systempreviously described:

1. The fitness function must expose the GP to all the cases.

2. An addition test function needs to be added to the existing functionset.

Two methods of modelling this behaviour suggest themselves. Firstly, aprobabilistic or sampling model that only subjects each individual to asubset of possible sequences. Secondly, a deterministic approach thatmodel the complete set of behaviour required by any correct solution.

The probabilistic method requires only a single fitness run for eachindividual, the fitness case being selected on a weighted random basisfrom all possible fitness cases. The obvious attraction is that thenumber of fitness tests could be less than the deterministic method.However, there are several difficulties with this method. Firstly thereis danger of losing useful genetic material and finding a poor localminimum if an individual should score poorly for the normal case, but infact contain a good solution for the error case. Secondly, if the errorcases are only evaluated on average according to their probability ofoccurring, then the error cases will not have as much exposure to thenormal evolutionary effects as the normal case. If this were to happen,then the normal cases would likely at a rate similar to the single case,while the error cases would require additional computational effort toyield a highly fit individual.

The third party is more fundamental in that to identify 100% fitindividuals, all paths must be traversed at some point. If this is donefor each generation then this degenerates into the deterministic methoddescribed next, or it must be done at prescribed points, for instanceafter a given number of generations. The question then arises as to whatthe real fitness criteria is. Is it the partial result fromprobabilistically selecting a subset of all paths, or is it the completeset of path traversals?

Because of this fundamental problem, this approach was not pursued anyfurther. An alternative is suggested by Gathercole [GR94] and [GR97] inadaptively modifying how many fitness cases should be used with atechnique called Dynamic Subset Selection (DSS).

When considering the alternative deterministic method we are concernedwith achieving a full coverage of all possible sequences of events andmessages. This would ensure that all cases have an equal chance ofevolving correctly. The major disadvantage, at least for large problems,is the time required to fully evaluate each case, since each individualmust be subjected to all possible cases.

The number of fitness tests is proportional to the number of paths inthe problem N. If all possible paths are the same length, then the netresult on the time required to find a solution would be at least N timesthe time required for the case where a single thread of control existed.The real problem is that the number of paths is likely to increaseexponentially in the number of nodes that must handle error cases.

The number of paths has been restricted to two.

The new function added to the function set F is the equality test FEQ.This takes three arguments and operates as follows:

The first argument is evaluated and if the integer portion of the resultis equal to 1, then the second argument is evaluated, else the thirdargument is evaluated. The result of the final argument evaluated isreturned.

The performance results are shown in FIG. 20.

Number successful at Number of different Effort ε generation   100% fitprograms   8,500 17 17

Experiment 4. Run-time Decision Making—More Complex Case

The previous case involved the service in making a decision early in itsexecution tree. This case involves making a decision later in the treewhere, for instance, the database cannot find a record corresponding tothe key. Other failures such as an internal database error or acommunication failure are also covered by this example. The decisionpoint was moved to see what effect on the evolutionary process was ofdelaying the point at which the branch was required.

The response from the database contains an additional parameter, in thiscase used to indicate success or failure. It is an integer value thattakes the value 0 indicating normal operation, or 1 indicating an errorcondition. The error condition results in the value returned by theerror response being sent as the translated address.

This case uses the same function set as previously, and uses the fullcoverage (deterministic) method of fitness evaluation.

The summary is shown in the table below.

The message sequence chart is shown in FIG. 21, the state diagram inFIG. 22 and the performance in FIG. 23.

Number successful at Number of different Effort ε generation 200   100%fit programs   12,500 11 11

The graph clearly shows the inferior performance of this experimentusing the standard value of M=500, the effort being much greater than2*ε for experiment 1. Obviously other factors come into play when tryingto evolve such a program.

Experiment 5. Reduced Complexity Function Set

Earlier the choice of function set was discussed. This experiment wasdevised to give an indication of whether the original level ofabstraction was reasonable or whether by using a lower level ofabstraction in the function set better performance could be achieved. Aliterature search failed to find any detailed discussion of this aspectof GP. Most problems discussed in the literature deal in small problemswhose function and terminal set are fairly obvious.

The input for this experiment is identical to that described in section5.3. This case was chosen since it was the first experiment that had avalue of υ of <50 and was therefore seen as not trivial.

The high level functions FSTART, FDBREAD, FROUTE and FEND were removedand two new functions ReadMSG and SendMSG were added.

ReadMSG accepts an incoming message and places the parameters intomemory locations as provided by the arguments to this function. In thiscase, only one parameter is accepted.

SendMSG constructs a message containing a message type and a singleparameter value.

Earlier it was indicated that the lower the level of abstraction themore functions would be needed. The fact that there are two fewerfunctions for this experiment compared to Experiment 2 is explained bythe fact that the higher level functions FSTART etc are synthesised fromthese lower level functions.

Lastly, the memory cells were extended to contain a message type,enumerated over the range of message types required.

The overall performance of the system when using lower level functionsis shown in FIG. 24 and a summary of performance is shown below.

Number successful at Number of different Effort ε generation 200   100%fit programs ψ 1,500 49 49

It is interesting to note the performance in comparison to that usinghigher level functions in FIG. 11. The effort curve R(z) reaches thevalue 10 at an earlier point and the probability curve is also steeper.The disadvantage of this method though is the more CPU time required toprocess each run. This is shown in Table 12 and may be an importantfactor when considering the scalability of GP.

As an example of the difference in output, an example from thisexperiment, run 1 is shown in FIG. 25.

An interesting feature of this particular example is the regularity withwhich the pattern at nodes 3, 4, 5, 6 and 7 occur. This pattern isrepeated at the sub-trees rooted as nodes 10 and 18. It is likely thatusing Automatically Defined Functions (ADFs) [Koz94] for this level offunctions would be beneficial since there are repeating patternsemerging.

In order to be able to estimate the difficulty of any problem, somemeans of expressing the problem in its constituent parts is required.The table below summarises the experiments in terms of the problemcomplexity, and the corresponding results.

In all cases, the results are for a population M=500, and the number ofgenerations I=200.

The average time for a run to complete is taken as the total wall clocktime of the experiment divided by the number of runs, which was 50 ineach case.

Output results Input requirements Av. time Av. Exp. Input per runComplex No. States Params. Paths (secs) of fittest P (M, i) R (z) ε 1 62 1 42 13 81 3 1,500 2 8 3 1 44 19 72 4 2,000 3 6 2 2 117 21 25 17 8,5004 9 3 2 124 32 17 25 12,500 5 8 3 1 71 28 82 3 1,500

The data presented is not the only data pertaining to the experimentsbut attempts to identify any useful patterns that may exist in thesystem.

The day presented is not the only data pertaining to the experiments butattempts to identify any useful patterns that may exist in the system.

Considering the experiments referred to above, the results presented inexperiment 2 show that even for small problems, there is more than oneprogram that satisfies the problem statement. This can be argued as trueprogram induction taking place, since any mechanical translation ormapping of the input specification would result in the same programevery time. Surprisingly, every experiment resulted in 100% diversity inthe solutions found giving some indication of the size of the solutionspace, even when using a small number of nodes. This result is importantsince it confirms the idea that for any given problem statement there isa very large number of possible programs that satisfy the problemstatement.

It is clear from the experiments, that as the problems get ‘harder’ thelonger a solution will take to be found, and the greater the populationsize or the greater the number of attempts required to find a solution.Unfortunately, there is no standard measure of difficulty in the currentGP literature. This is a problem when trying to determine the settingsto use in systems to get the best results.

In the context what is described, the difficult of any problem isrelated to a number of factors:

1. The number of states in the input requirements

2. The number of messages it has to handle

3. The number and position of decision points required

Handling decision points required much more computational effort to finda correct program. In a real service, there would be many such decisionpoints, and it is not clear how well this approach can scale toaccommodate this requirement.

Much of the literature is concerned with solving problems that have no100% correct solution. In the problem domain of IN however it is notsensible to consider anything but a 100% correct program. Barringoperating system and hardware faults, it is expected that a service willoperate correctly for all customers all the time.

This has two effects on using GP.

The evaluation of fitness is simpler since there is no doubt as towhether a program is successful or not.

It requires that the fitness cases cover 100% of the possibilities. Inthe problems considered here, this is not an issue, but when there aremany decision points, the number of fitness cases increases greatly.This obviously has an effect on the time required to complete a run.

The set of control parameters used for the experiments (APPENDIX B) wasprobably not optimal.

Two questions arise from this:

1. Is there an envelope of operation that gives good results?

2. Is it possible to determine all environment control values by somemethod?

It should also be noted, that although studies into different controlparameter values has shown evidence of some measurable effect onparticular problems the scale of effect is often small, and theuniversality of the effect is often limited, as for instance reported byGoldberg [GKH95] in his study on deme size, and the results presented aspart of the GP kernal [Wei97]. These and other questions raises thepoint made by Goldberg [GO98] that unlike GA there is no goodtheoretical basis for GP, and that until one is developed we are relianton empirical methods for determining the operational parameters for GP.

The use of APAMS was very powerful. It meant that evolving programs werenot constrained in the shape they took. The memory locations were usedfor several different purposes in the experiments—targets for storingmessage parameters, both string and integer, and a source for functionarguments, and as a constant value as when used by some examples usingthe FEQ function. In the last experiment they also contained messagetypes. Extension of APAMS would prove beneficial in future developmentssuch as using it to hold partial or complete messages.

APAMS also contributed to the great variety seen in the 100% correctsolutions by avoiding the need to restrict the semantic structure as in[HWSS95], [Mon95], [CY97] and others. To examine this claim, a simplehypothetical case can be considered such as the FSTART function. Astrict typing of this by a human programmer during the early stages ofbuilding a GP system could define this function returning a status, orparticular parameter to a calling function and having arguments of typeDialledNumber for the first and some other type for the second.Immediately it can be seen that by adding these constraints, a humanprogrammer imposes their own perceived structure on the function andtherefore it's place in any tree. Doing this would preclude two out ofthree solutions in Experiment 2.

The work originally by Koza [Koz92] used LISP as the implementationlanguage. This was attractive in one sense in that the programs thatwere evolved were LISP s-expressions, and could be executed by therun-time environment without any external translation. Using C++ meansthat the structures being evolved cannot be used directly as programsand an additional stage needs to be added if the output is to be used inany practical application. This does have one big advantage however, inthat the structures can be viewed as high level languages and aretherefore amenable to mechanical translation and optimisation, forexample using the techniques described in [Ben96] and [Hlb96].

The original choice of abstraction for the internal nodes gavesatisfactory results, but as shown in experiment 5, a lower level ofabstraction gives a better overall performance (higher probability ofyielding a 100% correct program) using the same basic systemarchitecture, but required approximately 40% more processing effort.Interestingly the average complexity of the reduced complexityexperiment was also approximately 40% greater than the standardexperiment. This suggests there may be a direct link between the twomeasures. Additionally, it is suggested that using ADFs could well beuseful in this case. Clearly more work is required in order to arrive atan optical level of abstraction.

The initial choice of the function set and terminal set had someinteresting properties. Firstly, most of the external behaviour wasdetermined by the state affecting functions FSTART, BDBREAD, FROUTE andFEND. The only non state affecting function STRSUB and in laterexperiments FEQ had the ability to appear in a program in one of twomodes:

1. Result affecting

2. Non result affecting.

The latter mode introduced introns into the program, allowing it toevolve via more than one route. Clearly, the state affecting functionscould not operate as introns. The use of Explicitly Defined Introns(EDI) as described by Nordin [NFB96] has the potential to improve theperformance of GP, but it has also been reported by Blickle [Bli96] andAndre [AT96] that EDI can degrade the performance in some applications.The utility of EDI appears to be problem specific.

A question that arises when this type of system is discussed is thedegree of confidence with which the result can be trusted. There is aperception that a program created by human is somehow more trustworthythan one created by a machine. This perception is not helped whenlooking at large, apparently unstructured programs generated by GPsystems. The flaw in this perception is that for all programs whethercreated by a human or by some mechanical means the final arbiter ofcorrectness is the behaviour of the program, or more properly does theprogram behave as the specification requires it to? Consider a commonexample of a simple C program such as shown in FIG. 26:

While the program may be obvious to a human reader, the output from anoptimising compiler would be hard to follow, and the execution orderingof the machine instructions in a modern RISC chip could be understood byonly the most knowledgeable of engineers, yet our experience gives usconfidence that the program will work correctly.

The opaqueness of machine generated programs can of course be consideredto be a positive attribute in that it forces the systems engineer tolook more closely at the specification and the associated systemtesting. A consequence of this is that the systems engineer must specifyexactly what the system should do, not as the introduction to Koza'sthird book [KABK98] states ‘ . . . a high level statement of therequirements . . . ’.

The question concerning the opaqueness of programs generated using GP orother EC technique has inspired some work to try to address theperceived deficiency. For instance Pringle [Pri95] suggests an approachthat tries to create programs that look like those produced by a humanprogrammer, while Langdon [Lan98] has dedicated a whole book toautomatic programming adopting techniques used by human programmers asbuilding blocks. A potential flaw in this approach is that practicessuch as modularity, data hiding, object oriented disciplines, datastructures and other ‘good engineering practices’ have been developed toaid human programmers in writing fault free and maintainable software.They are not of themselves required for a program to be correct andwhile the aforementioned work has delivered some useful techniques andinsights it does not address any of the essential features of GP. Acounter argument has been made by Blickle [Bli96] pointing out that aclear structured program can give valuable insights into the problembeing solved. For example when trying to find an analytical expressionto difficult integral equations, a clear analytic expression would allowfurther investigation of the problem. However it is worth revisiting theoriginal inspiration for this work and noting that Darwin observed‘nature cares nothing for appearances, except so far as they may beuseful to any being’ [Dar1859] (Chapter IV, ‘Natural Selection’).

Lastly the question of whether GP can perform as well as or better thana human programmer needs to be considered. Earlier it was claimed thatGP would only be worthwhile if it could generate an implementation in ashorter time and with fewer defects that a human. The problemsconsidered in this paper have been trivial compared to those encounteredin existing IN systems, and comparing these results directly with ahuman is not a reliable indication of scalability. However an indicationthat GP is as least as good as a human for simple services can be seenwhen ad-hoc experiments with a few engineers show that a simple numbertranslation service requires less than an hour of effort to completeusing Inventor. This compares well with the results in Table 12. If thefirst correct program was chosen, then the time required by GP can bemeasured in minutes.

As has been shown above, Genetic Programming can be used to generateservice logic for an Intelligent Network application, namely NumberTranslation.

Once the system had been set-up, the elapsed time required to create theservice logic program was several orders of magnitude less than usingthe existing manual tool-kits available for simple services, therebypotentially reducing the time required to create IN services.

The level of defects in the generated application due to implementationerrors is zero due to the fitness evaluation applied to the application.The level of defects due to errors in requirements should be reducedsince more attention is needed at the specification stage.

What is presented uses a new and novel memory architecture, whichremoves the need for strict typing. In contrast to strict typing, thereis no such thing as a syntactically incorrect program, which leaves theGP system free to evolve a semantically solution.

Appendix A. Glossary

This appendix explains the abbreviations used which are specific totelecommunications and Intelligent Networks.

DTMF Dual Tone Multi Frequency. A dual audio tone signalling method usedby telephone instruments to indicate to the switch the digits 0-9 andthe * and # symbols.

ICON A graphical abstraction of a building block used in the GPT GAINInventor™ product

IN Intelligent Networks. The use of standard computing platforms toextend the functionality of traditional telephone networks.

INAP Intelligent Network Application Part. The standard protocol definedto allow the SSP and SCP to communicate with each other.

SCP Service Control Point. The Intelligent network node that containsthe service logic programs.

SDP Service Data Point. This function provides traditional databasesupport the service logic.

SS7 Signalling System number 7. An internationally agreed standard forcarrying signalling information between nodes in a telephony network.

SSP Service Switching Point. The traditional Stored Program switch thatcontains the IN trigger and message functions.

SMP Service Management Point. A network and customer management system.

TCAP Transaction Capability Part. The transaction layer in the SS7stack.

Appendix B. Run Time Parameter Values

Within the GP Kernal there are a number of tuneable parameters. In orderto gain an insight into the performance of GP for different problemswithout introducing other variables, the variable factors were kept thesame throughout all the experiments and are listed here for reference.

Parameter Value Comments PopulationSize 10 NumberofGenerations 200CreationType 2 2 = ramped half and half CrossoverProbability 100Crossover operations will always be used CreationProbability 0 Noreplacement of a subtree with random subtree during crossoverMaximumDepthForCreation 10 MaximumDepthForCrossover 17 SelectionType 1Use tournament selection TournamentSize 10 Size of the tournamentDemeticGrouping 1 ON DemeSize 10 DemeticMigProbability 10SwapMutationProbability 10 ShrinkMutationProbability 10 SteadyState 0Not steady state AddBestToNewPopulation 1 Always reproduce best ofgeneration

Bibliography

[ABK96] Andre D, Bennett III and Koza J R. Discovery by GeneticProgramming of a Cellular Automata Rule that is Better than any KnownRule for the Majority Classification Problem. In Koza J R, Goldberg D E,Fogel D, and Riolo R. (Eds). Genetic Programming 1996: Proceedings ofthe First Annual Conference, pp.3-11, Jul. 28-31, 1996, StanfordUniversity. Cambridge, Mass. MIT Press.

[Ang97a] Angeline P. Subtree Crossover: Building Block Engine orMacromutation? pp.9-17 In Koza J, Deb K Dorigo M, Fogel D. B, Garzon M,Iba H, and Riolo R (Eds.) Genetic Programming 1997. Proceedings of theSecond Annual Conference Jul. 13-16, 1997 Stanford University. MorganKaufmann Publishers, San Francisco, Calif.

[ASS97] Aiyark P, Saket, A. S and Sinclair, M. C., Genetic ProgrammingApproaches for Minimum Cost Topology Optimisation of OpticalTelecommunications Networks, Proc. IEE/IEEE Intl. Conf. On GeneticAlgorithms in Engineering Systems: Innovations and Applications (GALESIA'97), University of Strathclyde, Glasgow, September 1997, pp.415-420.

[Ban93] Banzhaf W. Genetic programming for pedestrians. In Forrest S.Examining Division., proceedings of the 5^(th) International Conferenceon Genetic Algorithms, ICGA-93. Page 628, University of Illinois atUrbana-Champaign, 17-21 Jul., 1993. Morgan Kaufmann.

[BFN99] Banzhaf W., Francone F., and Nordin P. The Effect of ExtensiveUse of the Mutation Operator on Generalization in Genetic ProgrammingUsing Sparse Data Sets. In Goos G., Hartmanis J., and van Leewen J.(Eds.) Parallel Problem Solving from Nature: Proceedings InternationalConference on Evolutionary Computation, The 4^(th) Conference onParallel Problem Solving from Nature, Berlin, Germany, Sep. 22-26, 1996,Springer-Verlag.

[BNO97] Banzhaf W, Nordin P, and Olmer M. Generating AdaptiveBehaviourfor a Real Robot using Function Regression within GeneticProgramming. Pp.35-43 In Koza, J, Deb K Dorigo M, Fogel D. B, Garzon M,Iba H, and Riolo R (Eds.) Genetic Programming 1997. Proceedings of theSecond Annual Conference Jul. 13-16, 1997 Stanford University. MorganKaufmann Publishers, San Francisco, Calif.

[Ben96] Bennet, Jeremy, P., Introduction to Compiling Techniques. SecondEdition, 1996. McGraw-Hill Publishing Company, England.

[BG95] Bergadano F, and Gunetti D. 1995. Inductive Logic Programming:From Machine Learning to Software Engineering. MIT Press, 1995.

[Bli96] Blickle. T. Evolving Compact Solutions in Genetic Programming: ACase Study. In Voight H., Ebeling W., Recenberg I., Schwefel H., (Eds.):Parallel Problem Solving from Nature IV. Proceedings of theInternational Conference on Evolutionary, Berlin, September 1996, LNCS1141, pp.564-573, Heidelberg. Springer-Verlag.

[Boe81] Boehm B. W. Software Engineering Economics. 1981 Prentice Hall.

[CY97] Clack T, and Yu T. Performance Enhanced Genetic Programming. InAngeline P., Reynolds R., McDonald J., and Eberhart R., Eds.,Proceedings of the sixth conference on Evolutionary Programming, Volume1213 of Lecture Notes in Computer Science, Indianapolis, Ind., USA 1997,Springer-Verlag.

[Dar1859] Darwin, Charles. On the origin of species by Means of naturalSelection, or the Preservation of Favoured Races in the Struggle forLife. 1^(st) Edition. 1859.

[Dav93] Davis A M. Software Requirements; Objects, Functions and States.1993. Prentice Hall.

[Ebe98] Eberhagen S. Considerations for a successful introduction ofIntelligent Networks from a marketing perspective. In the Proceedings ofthe 5^(th) International Conference on Intelligence in Network,Bordeaux, France. 13/15 May 1998. Adera, France.

[GR94] Cathercole C and Ross P. Dynamic Training Subset Selection forSupervised Learning in Genetic Programming. Davidor Y, Schwefel H andManner R (Eds) Parallel Problem Solving from Nature III, Jerusalem, 9-14Oct. 1994. Springer-Verlag.

[GR97] Gathercole C and Ross P. Small Populations over Many Generationscan beat Large Populations over Few Generations in Genetic Programming.Pp.111-118 In Koza J, Deb K Dorigo M, Fogel D. B, Garzon M, Iba H, andRiolo R (Eds.) Genetic Programming 1997. Proceedings of the SecondAnnual Conference July 13-16, 1997 Stanford University. Morgan KaufmannPublishers, San Francisco, Calif.

[GD91] Goldberg D. E., and Deb K. 1991. A comparative analysis ofselection schemes used in genetic algorithms. In Rawlings G. (ExaminingDivision), Foundations of Genetic Algorithms Morgan Kaufmann.

[GKH95] Goldberg, David E, Kargupta Hillol, Horn Jeffrey and Cantu-PazErik. Critical Deme Size for Serial and Parallel Genetic Algorithms.IIliGAL Report No. 95002 January 1995.

[GO98] Goldberg, David E., and O'Reilly, Una-May. Where Does the GoodStuff Go, and Why? How Contexual semantics influences program structurein simple genetic programming, in Banzhaf W., Poli R., Schoenauer M.,and Fogarty T. C., (Eds.): First European Workshop, EuroGP'98, Paris,

France, April 1998 Proceedings. LNCS 1391, Springer-Verlag.

[Mar96] Martin, Peter, N. Service Creation for Intelligent Networks:Delivering the Promise. Proceedings of the 4^(th) InternationalConference on Intelligence in Networks, Bordeaux. 1996. ADERA.

[Mar95] Montana, David, J. Strongly Typed Genetic Programming.Evolutionary Computation. Volume 3, Issue 2, pp.199-230. Summer 1995.MIT Press.

[NFB96] Nordin P., Francone F., and Banzhaf W. Explicitly DefinedIntrons and Destructive Crossover in Genetic Programming. In Angeline.,and Kinnear K., Eds., Advances in Genetic Programming 2, Chapter 6, pp.111-134. MIT Press, Cambridge, Mass., USA, 1996.

[Per94] Perkis, Timothy. Stack Based Genetic Programming. In theproceedings of the 1994 IEEE World Congress on ComputationalIntelligence 1994. Volume 1, pages 148-153, Orlando, Fla., USA, 27-29June 1994. IEEE Press.

Pri95] Pringle W. ESP: Evolutionary Structured Programming. TechnicalReport, Penn State University, Greate Valley Campus, Pa., USA, 1995.

[SEL95] Sharman K., Anna I. Esparcia A., and Yun Li. Evoking signalprocessing algorithms by genetic programming. In A. M. S. Zalzala,editor, First International Conference on Genetic Algorithms inEngineering Systems: Innovations and Applications, (GALESIA), volume414, pages 473-480, Sheffield, UK, 12-14 Sep. 1995. IEE.

(SS97] Sinclair M., and Shami S. Evolving Simple Software Agents:Comparing Genetic Algorithm and Genetic Programming Performance.Proceedings of the second IEE/IEEE Intl. Conf. On Genetic Algorithms nEngineering Systems: Innovations and Applications (GALESIA '97),University of Strathclyde, Glasgow, September 1997, pp.421-426.

[Som96] Sommerville I. Software Engineering. Fifth Examining Division.1996. Addison Wesley Publishers Ltd.

[TCM98] Tang L. Califf M., Mooney R. An Experimental Comparison ofGenetic Programming and Inductive Logic Programming on LearningRecursive List Functions. Technical Report, University of Texas, Austin.Number A198-27. March 1998.

[Tel94] Teller, Astro. Turing Completeness in the Language of GeneticProgramming with Indexed Memory. Proceedings of the 1994 IEEE WorldCongress on Computational Intelligence, volume 1, Orlando, Fla., USA.June 1994. IEEE Press.

[TA97] Teller, Astro and Andre David. Automatically choosing the Numberof fitness Cases: The rational Allocation of Trials. pp.321-328 In KozaJ, Deb K, Dorigo M, Fogel D. B, Garzon M, Iba H, and Riolo R (Eds.)Genetic Programming 1997. Proceedings of the Second Annual ConferenceJul. 13-16, 1997 Stanford University. Morgan Kaufmann Publishers, SanFranscisco, Calif.

[Hol92] Holland, John, J. Adaptation in Natural and Artificial Systems:Ann Arbor, Mich.: University of Michigan Press 1975. Revised 2^(nd)edition 1992 from the MIT press.

[Hlb90] Holub, Alan, I., Compiler Design in C. 1^(st) edition. PrenticeHall.

[HWSS95] Haynes, T., Wainwright R., Sen S., and Schoenefeld D., StronglyTyped Genetic Programming in Evolving Cooperation Strategies. InEshelman L., (Examining Division) Genetic Algorithms: Proceedings of theSixth International Conference (ICGA95), pages 271-278, Pittsburgh,Pa.<USA, 15-19 Jul. 1995. Morgan Kaufmann.

[Iba96] Iba, Hitoshi Random Tree Generation for Genetic Programming. InGoos G., Hartmanis J., and van Leewen J. (Eds.) Parallel Problem Solvingfrom Nature: Proceedings International Conference on EvolutionaryComputation, The 4^(th) Conference on Parallel Problem Solving fromNature, Berlin, Germany, Sep. 22-26, 1996, Springer-Verlag.

[(Itu94a] ITU-T Q.1211. Introduction to Intelligent Networks CS-l 1994.6

[JCC92] Jefferson D, Collins R, Copper C, Dyer M, Flowers M Karf R,Taylor C and Wang A. Evolution as a theme in Artificial Life: TheGenesys/Tracker System. In Langton C et al (Eds), Artificial Life II.1992. Addison-Wesley Publishing Company Inc.

Koz92] Koza, John, R. Genetic Programming. On the Programming ofComputers by Means of Natural Selection. 1^(st) Edition MIT Press 1992.

[Koz94] Koza John R. Genetic Programming II. Autonatic Discovery ofReusable Programs. 1^(st) Edition MIT Press, 1994.

[Koz96] Koza John R. Comments on Cross Paradigm Comparisons of GeneticProgramming with existing machine learning paradigms.

[KBF96] Koza J R, Bennett III, Forrest H, Andre D, Keane M. AutomatedWYWIWYG design of both the topology and component values of analogueelectrical circuits using genetic programming. In Koza J R, Goldberg DE, Fogel D, and Riolo R. (Eds). Genetic Programming 1996: Proceedings ofthe First Annual Conference, Jul. 28-31, 1996, Stanford University.Cambridge, Mass. MIT Press.

[KABK98] Koza John R. Andre David, Bennett Forret H and Keane, Martin.Genetic Programming III Unpublished draft version, available on the GPMAILING LIST.

[Lan97] Langdon W B. ntrees. cc—A program to calculate size of GP randomtrees. cs.bham.ac.uk/pub/authors/W.B,Langdon/gp-code Visited 14^(th)Jun. 1997.

[Lan98] Langdon W B. Genetic Programming and Data structures: GeneticProgramming and Data structures=Automatic Programming! 1^(st) Edition.The Kluwer International Series in Engineering and Computer Science.Vol. 438. Kluwer Academic Publishers, Boston, 1998.

[LS97] Luke S, and Spector L. A comparison of crossover and Mutation inGenetic Programming. In Koza, J, Deb K, Dorigo M, Fogel D. B, Garzon M,Iba H and Riolo R (Eds.) Genetic Programming 1997. Proceedings of theSecond Annual Conference, pp.240-248, Jul. 13-16, 1997 StanfordUniversity. Morgan Kaufmann Publishers, San Francisco, Calif.

What is claimed is:
 1. A method of creating a specified service having aseries of service requirements on an intelligent network (IN) systemincluding a basic call state machine (BCSM) and a service switchingpoint (SSP), the method comprising the steps of: a) creating programs tooperate the BCSM to provide said specified service from the servicerequirements necessary to provide said specified service, the programsbeing created by using evolutionary programming; b) evaluating a fitnessfunction as a weighted sum of a number of correctly sequenced messagesthat the SSP in the IN would see and a weighted sum of a number ofcorrect message parameters that the SSP would see for each of theprograms created; and c) selecting a program from the programs createdon the basis of an evaluated fitness function for each program.
 2. Themethod as claimed in claim 1, wherein the evolutionary programming isgenetic programming (GP).
 3. The method as claimed in claim 2, andfurther comprising the step of creating an initial population ofprograms using a ramped half and half method.
 4. The method as claimedin claim 1, wherein the fitness function is a simulation of the SSPinterface that can send a message to an individual program with dataparameters according to a relevant state diagram and accept messages andinspect message parameters according to the relevant state diagram. 5.The method as claimed in claim 4, wherein a data type is autonomouspolymorphic addressable memory.
 6. A service creation arrangement for aspecified service having a series of service requirements on anintelligent network (IN) system including a basic call state machine(BCSM) and a service switching point (SSP), comprising: programmingmeans using evolutionary programming for creating programs to operatethe BCSM to provide the specified service from the service requirements;fitness evaluating means for evaluating a fitness function as a weightedsum of a number of correctly sequenced messages that the SSP in the INwould see and a weighted sum of a number of correct message parametersthat the SSP would see for each of the programs created; and selectionmeans for selecting a program from the programs created on the basis ofan evaluated function for each program.
 7. The service creationarrangement as claimed in claim 6, wherein the programming means employsgenetic programming.
 8. The service creation arrangement as claimed inclaim 7, and further comprising initial population creation means forprograms which use a ramped half and half method.
 9. The servicecreation arrangement as claimed in claim 6, wherein the fitness functionprovides a simulation of the SSP interface that can send a message to anindividual program with data parameters according to a relevant statediagram and accept messages and inspect message parameters according tothe relevant state diagram.
 10. The service creation arrangement asclaimed in claim 6, wherein autonomous polymorphic addressable memory isused as a data type.